//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS IoTManagedIntegrations service.
///
/// Managed integrations is a feature of AWS IoT Device Management that enables developers to quickly build innovative IoT solutions. Customers can use managed integrations to automate device setup workflows and support interoperability across many devices, regardless of device vendor or connectivity protocol. This allows developers to use a single user-interface to control, manage, and operate a range of devices.
public struct IoTManagedIntegrations: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the IoTManagedIntegrations client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "IoTManagedIntegrations",
            serviceIdentifier: "api.iotmanagedintegrations",
            signingName: "iotmanagedintegrations",
            serviceProtocol: .restjson,
            apiVersion: "2025-03-03",
            endpoint: endpoint,
            errorType: IoTManagedIntegrationsErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Creates a new account association via the destination id.
    @Sendable
    @inlinable
    public func createAccountAssociation(_ input: CreateAccountAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAccountAssociationResponse {
        try await self.client.execute(
            operation: "CreateAccountAssociation", 
            path: "/account-associations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new account association via the destination id.
    ///
    /// Parameters:
    ///   - clientToken: An idempotency token. If you retry a request that completed successfully initially using the same client token and parameters, then the retry attempt will succeed without performing any further actions.
    ///   - connectorDestinationId: The identifier of the connector destination.
    ///   - description: A description of the account association request.
    ///   - name: The name of the destination for the new account association.
    ///   - tags: A set of key/value pairs that are used to manage the account association.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAccountAssociation(
        clientToken: String? = CreateAccountAssociationRequest.idempotencyToken(),
        connectorDestinationId: String,
        description: String? = nil,
        name: String? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAccountAssociationResponse {
        let input = CreateAccountAssociationRequest(
            clientToken: clientToken, 
            connectorDestinationId: connectorDestinationId, 
            description: description, 
            name: name, 
            tags: tags
        )
        return try await self.createAccountAssociation(input, logger: logger)
    }

    /// Creates a C2C (cloud-to-cloud) connector.
    @Sendable
    @inlinable
    public func createCloudConnector(_ input: CreateCloudConnectorRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCloudConnectorResponse {
        try await self.client.execute(
            operation: "CreateCloudConnector", 
            path: "/cloud-connectors", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a C2C (cloud-to-cloud) connector.
    ///
    /// Parameters:
    ///   - clientToken: An idempotency token. If you retry a request that completed successfully initially using the same client token and parameters, then the retry attempt will succeed without performing any further actions.
    ///   - description: A description of the C2C connector.
    ///   - endpointConfig: The configuration details for the cloud connector endpoint, including connection parameters and authentication requirements.
    ///   - endpointType: The type of endpoint used for the cloud connector, which defines how the connector communicates with external services.
    ///   - name: The display name of the C2C connector.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCloudConnector(
        clientToken: String? = CreateCloudConnectorRequest.idempotencyToken(),
        description: String? = nil,
        endpointConfig: EndpointConfig,
        endpointType: EndpointType? = nil,
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCloudConnectorResponse {
        let input = CreateCloudConnectorRequest(
            clientToken: clientToken, 
            description: description, 
            endpointConfig: endpointConfig, 
            endpointType: endpointType, 
            name: name
        )
        return try await self.createCloudConnector(input, logger: logger)
    }

    /// Create a connector destination for connecting a cloud-to-cloud (C2C) connector to the customer's Amazon Web Services account.
    @Sendable
    @inlinable
    public func createConnectorDestination(_ input: CreateConnectorDestinationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateConnectorDestinationResponse {
        try await self.client.execute(
            operation: "CreateConnectorDestination", 
            path: "/connector-destinations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Create a connector destination for connecting a cloud-to-cloud (C2C) connector to the customer's Amazon Web Services account.
    ///
    /// Parameters:
    ///   - authConfig: The authentication configuration details for the connector destination, including OAuth settings and other authentication parameters.
    ///   - authType: The authentication type used for the connector destination, which determines how credentials and access are managed.
    ///   - clientToken: An idempotency token. If you retry a request that completed successfully initially using the same client token and parameters, then the retry attempt will succeed without performing any further actions.
    ///   - cloudConnectorId: The identifier of the C2C connector.
    ///   - description: A description of the connector destination.
    ///   - name: The display name of the connector destination.
    ///   - secretsManager: The AWS Secrets Manager configuration used to securely store and manage sensitive information for the connector destination.
    ///   - logger: Logger use during operation
    @inlinable
    public func createConnectorDestination(
        authConfig: AuthConfig,
        authType: AuthType,
        clientToken: String? = CreateConnectorDestinationRequest.idempotencyToken(),
        cloudConnectorId: String,
        description: String? = nil,
        name: String? = nil,
        secretsManager: SecretsManager,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateConnectorDestinationResponse {
        let input = CreateConnectorDestinationRequest(
            authConfig: authConfig, 
            authType: authType, 
            clientToken: clientToken, 
            cloudConnectorId: cloudConnectorId, 
            description: description, 
            name: name, 
            secretsManager: secretsManager
        )
        return try await self.createConnectorDestination(input, logger: logger)
    }

    /// Create a product credential locker. This operation will trigger the creation of all the manufacturing resources including the Wi-Fi setup key pair and device certificate.
    @Sendable
    @inlinable
    public func createCredentialLocker(_ input: CreateCredentialLockerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCredentialLockerResponse {
        try await self.client.execute(
            operation: "CreateCredentialLocker", 
            path: "/credential-lockers", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Create a product credential locker. This operation will trigger the creation of all the manufacturing resources including the Wi-Fi setup key pair and device certificate.
    ///
    /// Parameters:
    ///   - clientToken: An idempotency token. If you retry a request that completed successfully initially using the same client token and parameters, then the retry attempt will succeed without performing any further actions.
    ///   - name: The name of the credential locker.
    ///   - tags: A set of key/value pairs that are used to manage the credential locker.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCredentialLocker(
        clientToken: String? = CreateCredentialLockerRequest.idempotencyToken(),
        name: String? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCredentialLockerResponse {
        let input = CreateCredentialLockerRequest(
            clientToken: clientToken, 
            name: name, 
            tags: tags
        )
        return try await self.createCredentialLocker(input, logger: logger)
    }

    ///  Create a destination. IoT managed integrations uses the destination to determine where to deliver notifications for a device.
    @Sendable
    @inlinable
    public func createDestination(_ input: CreateDestinationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDestinationResponse {
        try await self.client.execute(
            operation: "CreateDestination", 
            path: "/destinations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Create a destination. IoT managed integrations uses the destination to determine where to deliver notifications for a device.
    ///
    /// Parameters:
    ///   - clientToken: An idempotency token. If you retry a request that completed successfully initially using the same client token and parameters, then the retry attempt will succeed without performing any further actions.
    ///   - deliveryDestinationArn: The Amazon Resource Name (ARN) of the customer-managed destination.
    ///   - deliveryDestinationType: The destination type for the customer-managed destination.
    ///   - description: The description of the customer-managed destination.
    ///   - name: The name of the customer-managed destination.
    ///   - roleArn: The Amazon Resource Name (ARN) of the delivery destination role.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDestination(
        clientToken: String? = CreateDestinationRequest.idempotencyToken(),
        deliveryDestinationArn: String,
        deliveryDestinationType: DeliveryDestinationType,
        description: String? = nil,
        name: String,
        roleArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDestinationResponse {
        let input = CreateDestinationRequest(
            clientToken: clientToken, 
            deliveryDestinationArn: deliveryDestinationArn, 
            deliveryDestinationType: deliveryDestinationType, 
            description: description, 
            name: name, 
            roleArn: roleArn
        )
        return try await self.createDestination(input, logger: logger)
    }

    /// Set the event log configuration for the account, resource type, or specific resource.
    @Sendable
    @inlinable
    public func createEventLogConfiguration(_ input: CreateEventLogConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateEventLogConfigurationResponse {
        try await self.client.execute(
            operation: "CreateEventLogConfiguration", 
            path: "/event-log-configurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Set the event log configuration for the account, resource type, or specific resource.
    ///
    /// Parameters:
    ///   - clientToken: An idempotency token. If you retry a request that completed successfully initially using the same client token and parameters, then the retry attempt will succeed without performing any further actions.
    ///   - eventLogLevel: The logging level for the event log configuration.
    ///   - resourceId: The identifier of the resource for the event log configuration.
    ///   - resourceType: The type of resource for the event log configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createEventLogConfiguration(
        clientToken: String? = CreateEventLogConfigurationRequest.idempotencyToken(),
        eventLogLevel: LogLevel,
        resourceId: String? = nil,
        resourceType: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateEventLogConfigurationResponse {
        let input = CreateEventLogConfigurationRequest(
            clientToken: clientToken, 
            eventLogLevel: eventLogLevel, 
            resourceId: resourceId, 
            resourceType: resourceType
        )
        return try await self.createEventLogConfiguration(input, logger: logger)
    }

    /// Creates a managed thing. A managed thing contains the device identifier, protocol supported, and capabilities of the device in a protocol-specific format.
    @Sendable
    @inlinable
    public func createManagedThing(_ input: CreateManagedThingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateManagedThingResponse {
        try await self.client.execute(
            operation: "CreateManagedThing", 
            path: "/managed-things", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a managed thing. A managed thing contains the device identifier, protocol supported, and capabilities of the device in a protocol-specific format.
    ///
    /// Parameters:
    ///   - authenticationMaterial: The authentication material defining the device connectivity setup requests. The authentication materials used are the device bar code.
    ///   - authenticationMaterialType: The type of authentication material used for device connectivity setup requests.
    ///   - brand: The brand of the device.
    ///   - capabilities: The capabilities of the device such as light bulb.
    ///   - capabilityReport: A report of the capabilities for the managed thing.
    ///   - capabilitySchemas: The capability schemas that define the functionality and features supported by the managed thing, including device capabilities and their associated properties.
    ///   - classification: The classification of the managed thing such as light bulb or thermostat.
    ///   - clientToken: An idempotency token. If you retry a request that completed successfully initially using the same client token and parameters, then the retry attempt will succeed without performing any further actions.
    ///   - credentialLockerId: The identifier of the credential for the managed thing.
    ///   - metaData: The metadata for the managed thing.  The managedThing metadata parameter is used for associating attributes with a managedThing that can be used for grouping over-the-air (OTA) tasks. Name value pairs in metadata can be used in the OtaTargetQueryString parameter for the CreateOtaTask API operation.
    ///   - model: The model of the device.
    ///   - name: The name of the managed thing representing the physical device.
    ///   - owner: Owner of the device, usually an indication of whom the device belongs to. This value should not contain personal identifiable information.
    ///   - role: The type of device used. This will be the hub controller, cloud device, or AWS IoT device.
    ///   - serialNumber: The serial number of the device.
    ///   - tags: A set of key/value pairs that are used to manage the managed thing.
    ///   - logger: Logger use during operation
    @inlinable
    public func createManagedThing(
        authenticationMaterial: String,
        authenticationMaterialType: AuthMaterialType,
        brand: String? = nil,
        capabilities: String? = nil,
        capabilityReport: CapabilityReport? = nil,
        capabilitySchemas: [CapabilitySchemaItem]? = nil,
        classification: String? = nil,
        clientToken: String? = CreateManagedThingRequest.idempotencyToken(),
        credentialLockerId: String? = nil,
        metaData: [String: String]? = nil,
        model: String? = nil,
        name: String? = nil,
        owner: String? = nil,
        role: Role,
        serialNumber: String? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateManagedThingResponse {
        let input = CreateManagedThingRequest(
            authenticationMaterial: authenticationMaterial, 
            authenticationMaterialType: authenticationMaterialType, 
            brand: brand, 
            capabilities: capabilities, 
            capabilityReport: capabilityReport, 
            capabilitySchemas: capabilitySchemas, 
            classification: classification, 
            clientToken: clientToken, 
            credentialLockerId: credentialLockerId, 
            metaData: metaData, 
            model: model, 
            name: name, 
            owner: owner, 
            role: role, 
            serialNumber: serialNumber, 
            tags: tags
        )
        return try await self.createManagedThing(input, logger: logger)
    }

    /// Creates a notification configuration. A configuration is a connection between an event type and a destination that you have already created.
    @Sendable
    @inlinable
    public func createNotificationConfiguration(_ input: CreateNotificationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateNotificationConfigurationResponse {
        try await self.client.execute(
            operation: "CreateNotificationConfiguration", 
            path: "/notification-configurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a notification configuration. A configuration is a connection between an event type and a destination that you have already created.
    ///
    /// Parameters:
    ///   - clientToken: An idempotency token. If you retry a request that completed successfully initially using the same client token and parameters, then the retry attempt will succeed without performing any further actions.
    ///   - destinationName: The name of the destination for the notification configuration.
    ///   - eventType: The type of event triggering a device notification to the customer-managed destination.
    ///   - logger: Logger use during operation
    @inlinable
    public func createNotificationConfiguration(
        clientToken: String? = CreateNotificationConfigurationRequest.idempotencyToken(),
        destinationName: String,
        eventType: EventType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateNotificationConfigurationResponse {
        let input = CreateNotificationConfigurationRequest(
            clientToken: clientToken, 
            destinationName: destinationName, 
            eventType: eventType
        )
        return try await self.createNotificationConfiguration(input, logger: logger)
    }

    /// Create an over-the-air (OTA) task to update a device.
    @Sendable
    @inlinable
    public func createOtaTask(_ input: CreateOtaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateOtaTaskResponse {
        try await self.client.execute(
            operation: "CreateOtaTask", 
            path: "/ota-tasks", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Create an over-the-air (OTA) task to update a device.
    ///
    /// Parameters:
    ///   - clientToken: An idempotency token. If you retry a request that completed successfully initially using the same client token and parameters, then the retry attempt will succeed without performing any further actions.
    ///   - description: The description of the over-the-air (OTA) task.
    ///   - otaMechanism: The deployment mechanism for the over-the-air (OTA) task.
    ///   - otaSchedulingConfig: 
    ///   - otaTargetQueryString: The query string to add things to the thing group.
    ///   - otaTaskExecutionRetryConfig: 
    ///   - otaType: The frequency type for the over-the-air (OTA) task.
    ///   - protocol: The connection protocol the over-the-air (OTA) task uses to update the device.
    ///   - s3Url: The URL to the Amazon S3 bucket where the over-the-air (OTA) task is stored.
    ///   - tags: A set of key/value pairs that are used to manage the over-the-air (OTA) task.
    ///   - target: The device targeted for the over-the-air (OTA) task.
    ///   - taskConfigurationId: The identifier for the over-the-air (OTA) task configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createOtaTask(
        clientToken: String? = CreateOtaTaskRequest.idempotencyToken(),
        description: String? = nil,
        otaMechanism: OtaMechanism? = nil,
        otaSchedulingConfig: OtaTaskSchedulingConfig? = nil,
        otaTargetQueryString: String? = nil,
        otaTaskExecutionRetryConfig: OtaTaskExecutionRetryConfig? = nil,
        otaType: OtaType,
        protocol: OtaProtocol? = nil,
        s3Url: String,
        tags: [String: String]? = nil,
        target: [String]? = nil,
        taskConfigurationId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateOtaTaskResponse {
        let input = CreateOtaTaskRequest(
            clientToken: clientToken, 
            description: description, 
            otaMechanism: otaMechanism, 
            otaSchedulingConfig: otaSchedulingConfig, 
            otaTargetQueryString: otaTargetQueryString, 
            otaTaskExecutionRetryConfig: otaTaskExecutionRetryConfig, 
            otaType: otaType, 
            protocol: `protocol`, 
            s3Url: s3Url, 
            tags: tags, 
            target: target, 
            taskConfigurationId: taskConfigurationId
        )
        return try await self.createOtaTask(input, logger: logger)
    }

    /// Create a configuraiton for the over-the-air (OTA) task.
    @Sendable
    @inlinable
    public func createOtaTaskConfiguration(_ input: CreateOtaTaskConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateOtaTaskConfigurationResponse {
        try await self.client.execute(
            operation: "CreateOtaTaskConfiguration", 
            path: "/ota-task-configurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Create a configuraiton for the over-the-air (OTA) task.
    ///
    /// Parameters:
    ///   - clientToken: An idempotency token. If you retry a request that completed successfully initially using the same client token and parameters, then the retry attempt will succeed without performing any further actions.
    ///   - description: A description of the over-the-air (OTA) task configuration.
    ///   - name: The name of the over-the-air (OTA) task.
    ///   - pushConfig: Describes the type of configuration used for the over-the-air (OTA) task.
    ///   - logger: Logger use during operation
    @inlinable
    public func createOtaTaskConfiguration(
        clientToken: String? = CreateOtaTaskConfigurationRequest.idempotencyToken(),
        description: String? = nil,
        name: String? = nil,
        pushConfig: PushConfig? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateOtaTaskConfigurationResponse {
        let input = CreateOtaTaskConfigurationRequest(
            clientToken: clientToken, 
            description: description, 
            name: name, 
            pushConfig: pushConfig
        )
        return try await self.createOtaTaskConfiguration(input, logger: logger)
    }

    /// Create a provisioning profile for a device to execute the provisioning flows using a provisioning template. The provisioning template is a document that defines the set of resources and policies applied to a device during the provisioning process.
    @Sendable
    @inlinable
    public func createProvisioningProfile(_ input: CreateProvisioningProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateProvisioningProfileResponse {
        try await self.client.execute(
            operation: "CreateProvisioningProfile", 
            path: "/provisioning-profiles", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Create a provisioning profile for a device to execute the provisioning flows using a provisioning template. The provisioning template is a document that defines the set of resources and policies applied to a device during the provisioning process.
    ///
    /// Parameters:
    ///   - caCertificate: The id of the certificate authority (CA) certificate.
    ///   - clientToken: An idempotency token. If you retry a request that completed successfully initially using the same client token and parameters, then the retry attempt will succeed without performing any further actions.
    ///   - name: The name of the provisioning template.
    ///   - provisioningType: The type of provisioning workflow the device uses for onboarding to IoT managed integrations.
    ///   - tags: A set of key/value pairs that are used to manage the provisioning profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func createProvisioningProfile(
        caCertificate: String? = nil,
        clientToken: String? = CreateProvisioningProfileRequest.idempotencyToken(),
        name: String? = nil,
        provisioningType: ProvisioningType,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateProvisioningProfileResponse {
        let input = CreateProvisioningProfileRequest(
            caCertificate: caCertificate, 
            clientToken: clientToken, 
            name: name, 
            provisioningType: provisioningType, 
            tags: tags
        )
        return try await self.createProvisioningProfile(input, logger: logger)
    }

    /// Remove a third party account and related devices from an end user.
    @Sendable
    @inlinable
    public func deleteAccountAssociation(_ input: DeleteAccountAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteAccountAssociation", 
            path: "/account-associations/{AccountAssociationId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Remove a third party account and related devices from an end user.
    ///
    /// Parameters:
    ///   - accountAssociationId: The unique identifier of the account association to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAccountAssociation(
        accountAssociationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteAccountAssociationRequest(
            accountAssociationId: accountAssociationId
        )
        return try await self.deleteAccountAssociation(input, logger: logger)
    }

    /// Delete a cloud connector.
    @Sendable
    @inlinable
    public func deleteCloudConnector(_ input: DeleteCloudConnectorRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteCloudConnector", 
            path: "/cloud-connectors/{Identifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete a cloud connector.
    ///
    /// Parameters:
    ///   - identifier: The identifier of the cloud connector.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCloudConnector(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteCloudConnectorRequest(
            identifier: identifier
        )
        return try await self.deleteCloudConnector(input, logger: logger)
    }

    /// Delete a connector destination for connecting a cloud-to-cloud (C2C) connector to the customer's Amazon Web Services account.
    @Sendable
    @inlinable
    public func deleteConnectorDestination(_ input: DeleteConnectorDestinationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteConnectorDestination", 
            path: "/connector-destinations/{Identifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete a connector destination for connecting a cloud-to-cloud (C2C) connector to the customer's Amazon Web Services account.
    ///
    /// Parameters:
    ///   - identifier: The identifier of the connector destination.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteConnectorDestination(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteConnectorDestinationRequest(
            identifier: identifier
        )
        return try await self.deleteConnectorDestination(input, logger: logger)
    }

    /// Delete a credential locker.   This operation can't be undone and any existing device won't be able to use IoT managed integrations.
    @Sendable
    @inlinable
    public func deleteCredentialLocker(_ input: DeleteCredentialLockerRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteCredentialLocker", 
            path: "/credential-lockers/{Identifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete a credential locker.   This operation can't be undone and any existing device won't be able to use IoT managed integrations.
    ///
    /// Parameters:
    ///   - identifier: The identifier of the credential locker.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCredentialLocker(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteCredentialLockerRequest(
            identifier: identifier
        )
        return try await self.deleteCredentialLocker(input, logger: logger)
    }

    /// Deletes a customer-managed destination specified by id.
    @Sendable
    @inlinable
    public func deleteDestination(_ input: DeleteDestinationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteDestination", 
            path: "/destinations/{Name}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a customer-managed destination specified by id.
    ///
    /// Parameters:
    ///   - name: The id of the customer-managed destination.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDestination(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteDestinationRequest(
            name: name
        )
        return try await self.deleteDestination(input, logger: logger)
    }

    /// Delete an event log configuration.
    @Sendable
    @inlinable
    public func deleteEventLogConfiguration(_ input: DeleteEventLogConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteEventLogConfiguration", 
            path: "/event-log-configurations/{Id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete an event log configuration.
    ///
    /// Parameters:
    ///   - id: The identifier of the event log configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEventLogConfiguration(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteEventLogConfigurationRequest(
            id: id
        )
        return try await self.deleteEventLogConfiguration(input, logger: logger)
    }

    /// Delete a managed thing. If a controller is deleted, all of the devices connected to it will have their status changed to PENDING. It is not possible to remove a cloud device.
    @Sendable
    @inlinable
    public func deleteManagedThing(_ input: DeleteManagedThingRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteManagedThing", 
            path: "/managed-things/{Identifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete a managed thing. If a controller is deleted, all of the devices connected to it will have their status changed to PENDING. It is not possible to remove a cloud device.
    ///
    /// Parameters:
    ///   - force: When set to TRUE, a forceful deteletion of the managed thing will occur. When set to FALSE, a non-forceful deletion of the managed thing will occur.
    ///   - identifier: The id of the managed thing.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteManagedThing(
        force: Bool? = nil,
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteManagedThingRequest(
            force: force, 
            identifier: identifier
        )
        return try await self.deleteManagedThing(input, logger: logger)
    }

    /// Deletes a notification configuration.
    @Sendable
    @inlinable
    public func deleteNotificationConfiguration(_ input: DeleteNotificationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteNotificationConfiguration", 
            path: "/notification-configurations/{EventType}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a notification configuration.
    ///
    /// Parameters:
    ///   - eventType: The type of event triggering a device notification to the customer-managed destination.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteNotificationConfiguration(
        eventType: EventType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteNotificationConfigurationRequest(
            eventType: eventType
        )
        return try await self.deleteNotificationConfiguration(input, logger: logger)
    }

    /// Delete the over-the-air (OTA) task.
    @Sendable
    @inlinable
    public func deleteOtaTask(_ input: DeleteOtaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteOtaTask", 
            path: "/ota-tasks/{Identifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete the over-the-air (OTA) task.
    ///
    /// Parameters:
    ///   - identifier: The identifier of the over-the-air (OTA) task.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteOtaTask(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteOtaTaskRequest(
            identifier: identifier
        )
        return try await self.deleteOtaTask(input, logger: logger)
    }

    /// Delete the over-the-air (OTA) task configuration.
    @Sendable
    @inlinable
    public func deleteOtaTaskConfiguration(_ input: DeleteOtaTaskConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteOtaTaskConfiguration", 
            path: "/ota-task-configurations/{Identifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete the over-the-air (OTA) task configuration.
    ///
    /// Parameters:
    ///   - identifier: The identifier of the over-the-air (OTA) task configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteOtaTaskConfiguration(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteOtaTaskConfigurationRequest(
            identifier: identifier
        )
        return try await self.deleteOtaTaskConfiguration(input, logger: logger)
    }

    /// Delete a provisioning profile.
    @Sendable
    @inlinable
    public func deleteProvisioningProfile(_ input: DeleteProvisioningProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteProvisioningProfile", 
            path: "/provisioning-profiles/{Identifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Delete a provisioning profile.
    ///
    /// Parameters:
    ///   - identifier: The name of the provisioning template.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteProvisioningProfile(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteProvisioningProfileRequest(
            identifier: identifier
        )
        return try await self.deleteProvisioningProfile(input, logger: logger)
    }

    /// Deregisters an account association, removing the connection between a managed thing and a third-party account.
    @Sendable
    @inlinable
    public func deregisterAccountAssociation(_ input: DeregisterAccountAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeregisterAccountAssociation", 
            path: "/managed-thing-associations/deregister", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deregisters an account association, removing the connection between a managed thing and a third-party account.
    ///
    /// Parameters:
    ///   - accountAssociationId: The unique identifier of the account association to be deregistered.
    ///   - managedThingId: The identifier of the managed thing to be deregistered from the account association.
    ///   - logger: Logger use during operation
    @inlinable
    public func deregisterAccountAssociation(
        accountAssociationId: String,
        managedThingId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeregisterAccountAssociationRequest(
            accountAssociationId: accountAssociationId, 
            managedThingId: managedThingId
        )
        return try await self.deregisterAccountAssociation(input, logger: logger)
    }

    /// Get an account association for an Amazon Web Services account linked to a customer-managed destination.
    @Sendable
    @inlinable
    public func getAccountAssociation(_ input: GetAccountAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAccountAssociationResponse {
        try await self.client.execute(
            operation: "GetAccountAssociation", 
            path: "/account-associations/{AccountAssociationId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get an account association for an Amazon Web Services account linked to a customer-managed destination.
    ///
    /// Parameters:
    ///   - accountAssociationId: The unique identifier of the account association to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAccountAssociation(
        accountAssociationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAccountAssociationResponse {
        let input = GetAccountAssociationRequest(
            accountAssociationId: accountAssociationId
        )
        return try await self.getAccountAssociation(input, logger: logger)
    }

    /// Gets all the information about a connector for a connector developer.
    @Sendable
    @inlinable
    public func getCloudConnector(_ input: GetCloudConnectorRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCloudConnectorResponse {
        try await self.client.execute(
            operation: "GetCloudConnector", 
            path: "/cloud-connectors/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets all the information about a connector for a connector developer.
    ///
    /// Parameters:
    ///   - identifier: The identifier of the C2C connector.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCloudConnector(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCloudConnectorResponse {
        let input = GetCloudConnectorRequest(
            identifier: identifier
        )
        return try await self.getCloudConnector(input, logger: logger)
    }

    /// Get a connector destination of a cloud-to-cloud (C2C) connector connecting to a customer's Amazon Web Services account.
    @Sendable
    @inlinable
    public func getConnectorDestination(_ input: GetConnectorDestinationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetConnectorDestinationResponse {
        try await self.client.execute(
            operation: "GetConnectorDestination", 
            path: "/connector-destinations/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get a connector destination of a cloud-to-cloud (C2C) connector connecting to a customer's Amazon Web Services account.
    ///
    /// Parameters:
    ///   - identifier: The identifier of the C2C connector destination.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConnectorDestination(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConnectorDestinationResponse {
        let input = GetConnectorDestinationRequest(
            identifier: identifier
        )
        return try await self.getConnectorDestination(input, logger: logger)
    }

    /// Get information on an existing credential locker
    @Sendable
    @inlinable
    public func getCredentialLocker(_ input: GetCredentialLockerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCredentialLockerResponse {
        try await self.client.execute(
            operation: "GetCredentialLocker", 
            path: "/credential-lockers/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get information on an existing credential locker
    ///
    /// Parameters:
    ///   - identifier: The identifier of the credential locker.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCredentialLocker(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCredentialLockerResponse {
        let input = GetCredentialLockerRequest(
            identifier: identifier
        )
        return try await self.getCredentialLocker(input, logger: logger)
    }

    /// Returns the IoT managed integrations custom endpoint.
    @Sendable
    @inlinable
    public func getCustomEndpoint(_ input: GetCustomEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCustomEndpointResponse {
        try await self.client.execute(
            operation: "GetCustomEndpoint", 
            path: "/custom-endpoint", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the IoT managed integrations custom endpoint.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getCustomEndpoint(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCustomEndpointResponse {
        let input = GetCustomEndpointRequest(
        )
        return try await self.getCustomEndpoint(input, logger: logger)
    }

    ///  Retrieves information about the default encryption configuration for the Amazon Web Services account in the default or specified region. For more information, see Key management in the AWS IoT SiteWise User Guide.
    @Sendable
    @inlinable
    public func getDefaultEncryptionConfiguration(_ input: GetDefaultEncryptionConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDefaultEncryptionConfigurationResponse {
        try await self.client.execute(
            operation: "GetDefaultEncryptionConfiguration", 
            path: "/configuration/account/encryption", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Retrieves information about the default encryption configuration for the Amazon Web Services account in the default or specified region. For more information, see Key management in the AWS IoT SiteWise User Guide.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getDefaultEncryptionConfiguration(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDefaultEncryptionConfigurationResponse {
        let input = GetDefaultEncryptionConfigurationRequest(
        )
        return try await self.getDefaultEncryptionConfiguration(input, logger: logger)
    }

    /// Gets a destination by ID.
    @Sendable
    @inlinable
    public func getDestination(_ input: GetDestinationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDestinationResponse {
        try await self.client.execute(
            operation: "GetDestination", 
            path: "/destinations/{Name}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a destination by ID.
    ///
    /// Parameters:
    ///   - name: The name of the customer-managed destination.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDestination(
        name: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDestinationResponse {
        let input = GetDestinationRequest(
            name: name
        )
        return try await self.getDestination(input, logger: logger)
    }

    ///  Get the current state of a device discovery.
    @Sendable
    @inlinable
    public func getDeviceDiscovery(_ input: GetDeviceDiscoveryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDeviceDiscoveryResponse {
        try await self.client.execute(
            operation: "GetDeviceDiscovery", 
            path: "/device-discoveries/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Get the current state of a device discovery.
    ///
    /// Parameters:
    ///   - identifier: The id of the device discovery job request.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDeviceDiscovery(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDeviceDiscoveryResponse {
        let input = GetDeviceDiscoveryRequest(
            identifier: identifier
        )
        return try await self.getDeviceDiscovery(input, logger: logger)
    }

    /// Get an event log configuration.
    @Sendable
    @inlinable
    public func getEventLogConfiguration(_ input: GetEventLogConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEventLogConfigurationResponse {
        try await self.client.execute(
            operation: "GetEventLogConfiguration", 
            path: "/event-log-configurations/{Id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get an event log configuration.
    ///
    /// Parameters:
    ///   - id: The identifier of the event log configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func getEventLogConfiguration(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEventLogConfigurationResponse {
        let input = GetEventLogConfigurationRequest(
            id: id
        )
        return try await self.getEventLogConfiguration(input, logger: logger)
    }

    /// Get a hub configuration.
    @Sendable
    @inlinable
    public func getHubConfiguration(_ input: GetHubConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetHubConfigurationResponse {
        try await self.client.execute(
            operation: "GetHubConfiguration", 
            path: "/hub-configuration", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get a hub configuration.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getHubConfiguration(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetHubConfigurationResponse {
        let input = GetHubConfigurationRequest(
        )
        return try await self.getHubConfiguration(input, logger: logger)
    }

    ///  Get the attributes and capabilities associated with a managed thing.
    @Sendable
    @inlinable
    public func getManagedThing(_ input: GetManagedThingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetManagedThingResponse {
        try await self.client.execute(
            operation: "GetManagedThing", 
            path: "/managed-things/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Get the attributes and capabilities associated with a managed thing.
    ///
    /// Parameters:
    ///   - identifier: The id of the managed thing.
    ///   - logger: Logger use during operation
    @inlinable
    public func getManagedThing(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetManagedThingResponse {
        let input = GetManagedThingRequest(
            identifier: identifier
        )
        return try await self.getManagedThing(input, logger: logger)
    }

    /// Get the capabilities for a managed thing using the device ID.
    @Sendable
    @inlinable
    public func getManagedThingCapabilities(_ input: GetManagedThingCapabilitiesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetManagedThingCapabilitiesResponse {
        try await self.client.execute(
            operation: "GetManagedThingCapabilities", 
            path: "/managed-things-capabilities/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the capabilities for a managed thing using the device ID.
    ///
    /// Parameters:
    ///   - identifier: The id of the device.
    ///   - logger: Logger use during operation
    @inlinable
    public func getManagedThingCapabilities(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetManagedThingCapabilitiesResponse {
        let input = GetManagedThingCapabilitiesRequest(
            identifier: identifier
        )
        return try await self.getManagedThingCapabilities(input, logger: logger)
    }

    /// Get the connectivity status of a managed thing.
    @Sendable
    @inlinable
    public func getManagedThingConnectivityData(_ input: GetManagedThingConnectivityDataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetManagedThingConnectivityDataResponse {
        try await self.client.execute(
            operation: "GetManagedThingConnectivityData", 
            path: "/managed-things-connectivity-data/{Identifier}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the connectivity status of a managed thing.
    ///
    /// Parameters:
    ///   - identifier: The identifier of a managed thing.
    ///   - logger: Logger use during operation
    @inlinable
    public func getManagedThingConnectivityData(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetManagedThingConnectivityDataResponse {
        let input = GetManagedThingConnectivityDataRequest(
            identifier: identifier
        )
        return try await self.getManagedThingConnectivityData(input, logger: logger)
    }

    /// Get the metadata information for a managed thing.  The managedThing metadata parameter is used for associating attributes with a managedThing that can be used for grouping over-the-air (OTA) tasks. Name value pairs in metadata can be used in the OtaTargetQueryString parameter for the CreateOtaTask API operation.
    @Sendable
    @inlinable
    public func getManagedThingMetaData(_ input: GetManagedThingMetaDataRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetManagedThingMetaDataResponse {
        try await self.client.execute(
            operation: "GetManagedThingMetaData", 
            path: "/managed-things-metadata/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the metadata information for a managed thing.  The managedThing metadata parameter is used for associating attributes with a managedThing that can be used for grouping over-the-air (OTA) tasks. Name value pairs in metadata can be used in the OtaTargetQueryString parameter for the CreateOtaTask API operation.
    ///
    /// Parameters:
    ///   - identifier: The managed thing id.
    ///   - logger: Logger use during operation
    @inlinable
    public func getManagedThingMetaData(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetManagedThingMetaDataResponse {
        let input = GetManagedThingMetaDataRequest(
            identifier: identifier
        )
        return try await self.getManagedThingMetaData(input, logger: logger)
    }

    ///  Returns the managed thing state for the given device Id.
    @Sendable
    @inlinable
    public func getManagedThingState(_ input: GetManagedThingStateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetManagedThingStateResponse {
        try await self.client.execute(
            operation: "GetManagedThingState", 
            path: "/managed-thing-states/{ManagedThingId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Returns the managed thing state for the given device Id.
    ///
    /// Parameters:
    ///   - managedThingId: The id of the device.
    ///   - logger: Logger use during operation
    @inlinable
    public func getManagedThingState(
        managedThingId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetManagedThingStateResponse {
        let input = GetManagedThingStateRequest(
            managedThingId: managedThingId
        )
        return try await self.getManagedThingState(input, logger: logger)
    }

    ///  Get a notification configuration.
    @Sendable
    @inlinable
    public func getNotificationConfiguration(_ input: GetNotificationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNotificationConfigurationResponse {
        try await self.client.execute(
            operation: "GetNotificationConfiguration", 
            path: "/notification-configurations/{EventType}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Get a notification configuration.
    ///
    /// Parameters:
    ///   - eventType: The type of event triggering a device notification to the customer-managed destination.
    ///   - logger: Logger use during operation
    @inlinable
    public func getNotificationConfiguration(
        eventType: EventType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNotificationConfigurationResponse {
        let input = GetNotificationConfigurationRequest(
            eventType: eventType
        )
        return try await self.getNotificationConfiguration(input, logger: logger)
    }

    /// Get the over-the-air (OTA) task.
    @Sendable
    @inlinable
    public func getOtaTask(_ input: GetOtaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOtaTaskResponse {
        try await self.client.execute(
            operation: "GetOtaTask", 
            path: "/ota-tasks/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the over-the-air (OTA) task.
    ///
    /// Parameters:
    ///   - identifier: The over-the-air (OTA) task id.
    ///   - logger: Logger use during operation
    @inlinable
    public func getOtaTask(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOtaTaskResponse {
        let input = GetOtaTaskRequest(
            identifier: identifier
        )
        return try await self.getOtaTask(input, logger: logger)
    }

    /// Get a configuraiton for the over-the-air (OTA) task.
    @Sendable
    @inlinable
    public func getOtaTaskConfiguration(_ input: GetOtaTaskConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetOtaTaskConfigurationResponse {
        try await self.client.execute(
            operation: "GetOtaTaskConfiguration", 
            path: "/ota-task-configurations/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get a configuraiton for the over-the-air (OTA) task.
    ///
    /// Parameters:
    ///   - identifier: The over-the-air (OTA) task configuration id.
    ///   - logger: Logger use during operation
    @inlinable
    public func getOtaTaskConfiguration(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetOtaTaskConfigurationResponse {
        let input = GetOtaTaskConfigurationRequest(
            identifier: identifier
        )
        return try await self.getOtaTaskConfiguration(input, logger: logger)
    }

    /// Get a provisioning profile by template name.
    @Sendable
    @inlinable
    public func getProvisioningProfile(_ input: GetProvisioningProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetProvisioningProfileResponse {
        try await self.client.execute(
            operation: "GetProvisioningProfile", 
            path: "/provisioning-profiles/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get a provisioning profile by template name.
    ///
    /// Parameters:
    ///   - identifier: The provisioning template the device uses for the provisioning process.
    ///   - logger: Logger use during operation
    @inlinable
    public func getProvisioningProfile(
        identifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetProvisioningProfileResponse {
        let input = GetProvisioningProfileRequest(
            identifier: identifier
        )
        return try await self.getProvisioningProfile(input, logger: logger)
    }

    /// Get the runtime log configuration for a specific managed thing or for all managed things as a group.
    @Sendable
    @inlinable
    public func getRuntimeLogConfiguration(_ input: GetRuntimeLogConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRuntimeLogConfigurationResponse {
        try await self.client.execute(
            operation: "GetRuntimeLogConfiguration", 
            path: "/runtime-log-configurations/{ManagedThingId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the runtime log configuration for a specific managed thing or for all managed things as a group.
    ///
    /// Parameters:
    ///   - managedThingId: The id for a managed thing.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRuntimeLogConfiguration(
        managedThingId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRuntimeLogConfigurationResponse {
        let input = GetRuntimeLogConfigurationRequest(
            managedThingId: managedThingId
        )
        return try await self.getRuntimeLogConfiguration(input, logger: logger)
    }

    /// Gets a schema version with the provided information.
    @Sendable
    @inlinable
    public func getSchemaVersion(_ input: GetSchemaVersionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSchemaVersionResponse {
        try await self.client.execute(
            operation: "GetSchemaVersion", 
            path: "/schema-versions/{Type}/{SchemaVersionedId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a schema version with the provided information.
    ///
    /// Parameters:
    ///   - format: The format of the schema version.
    ///   - schemaVersionedId: Schema id with a version specified. If the version is missing, it defaults to latest version.
    ///   - type: The type of schema version.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSchemaVersion(
        format: SchemaVersionFormat? = nil,
        schemaVersionedId: String,
        type: SchemaVersionType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSchemaVersionResponse {
        let input = GetSchemaVersionRequest(
            format: format, 
            schemaVersionedId: schemaVersionedId, 
            type: type
        )
        return try await self.getSchemaVersion(input, logger: logger)
    }

    /// Lists all account associations, with optional filtering by connector destination ID.
    @Sendable
    @inlinable
    public func listAccountAssociations(_ input: ListAccountAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAccountAssociationsResponse {
        try await self.client.execute(
            operation: "ListAccountAssociations", 
            path: "/account-associations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all account associations, with optional filtering by connector destination ID.
    ///
    /// Parameters:
    ///   - connectorDestinationId: The identifier of the connector destination to filter account associations by.
    ///   - maxResults: The maximum number of account associations to return in a single response.
    ///   - nextToken: A token used for pagination of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAccountAssociations(
        connectorDestinationId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAccountAssociationsResponse {
        let input = ListAccountAssociationsRequest(
            connectorDestinationId: connectorDestinationId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAccountAssociations(input, logger: logger)
    }

    /// Returns a list of connectors based on permissions.
    @Sendable
    @inlinable
    public func listCloudConnectors(_ input: ListCloudConnectorsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCloudConnectorsResponse {
        try await self.client.execute(
            operation: "ListCloudConnectors", 
            path: "/cloud-connectors", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of connectors based on permissions.
    ///
    /// Parameters:
    ///   - lambdaArn: The Amazon Resource Name (ARN) of the Lambda function to filter cloud connectors by.
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - nextToken: A token that can be used to retrieve the next set of results.
    ///   - type: The type of cloud connectors to filter by when listing available connectors.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCloudConnectors(
        lambdaArn: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        type: CloudConnectorType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCloudConnectorsResponse {
        let input = ListCloudConnectorsRequest(
            lambdaArn: lambdaArn, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            type: type
        )
        return try await self.listCloudConnectors(input, logger: logger)
    }

    /// Lists all connector destinations, with optional filtering by cloud connector ID.
    @Sendable
    @inlinable
    public func listConnectorDestinations(_ input: ListConnectorDestinationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListConnectorDestinationsResponse {
        try await self.client.execute(
            operation: "ListConnectorDestinations", 
            path: "/connector-destinations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all connector destinations, with optional filtering by cloud connector ID.
    ///
    /// Parameters:
    ///   - cloudConnectorId: The identifier of the cloud connector to filter connector destinations by.
    ///   - maxResults: The maximum number of connector destinations to return in a single response.
    ///   - nextToken: A token used for pagination of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listConnectorDestinations(
        cloudConnectorId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListConnectorDestinationsResponse {
        let input = ListConnectorDestinationsRequest(
            cloudConnectorId: cloudConnectorId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listConnectorDestinations(input, logger: logger)
    }

    /// List information on an existing credential locker.
    @Sendable
    @inlinable
    public func listCredentialLockers(_ input: ListCredentialLockersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCredentialLockersResponse {
        try await self.client.execute(
            operation: "ListCredentialLockers", 
            path: "/credential-lockers", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List information on an existing credential locker.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - nextToken: A token that can be used to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCredentialLockers(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCredentialLockersResponse {
        let input = ListCredentialLockersRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCredentialLockers(input, logger: logger)
    }

    ///  List all destination names under one Amazon Web Services account.
    @Sendable
    @inlinable
    public func listDestinations(_ input: ListDestinationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDestinationsResponse {
        try await self.client.execute(
            operation: "ListDestinations", 
            path: "/destinations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  List all destination names under one Amazon Web Services account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - nextToken: A token that can be used to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDestinations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDestinationsResponse {
        let input = ListDestinationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDestinations(input, logger: logger)
    }

    /// Lists all device discovery tasks, with optional filtering by type and status.
    @Sendable
    @inlinable
    public func listDeviceDiscoveries(_ input: ListDeviceDiscoveriesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDeviceDiscoveriesResponse {
        try await self.client.execute(
            operation: "ListDeviceDiscoveries", 
            path: "/device-discoveries", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all device discovery tasks, with optional filtering by type and status.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of device discovery jobs to return in a single response.
    ///   - nextToken: A token used for pagination of results.
    ///   - statusFilter: The status to filter device discovery jobs by.
    ///   - typeFilter: The discovery type to filter device discovery jobs by.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDeviceDiscoveries(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        statusFilter: DeviceDiscoveryStatus? = nil,
        typeFilter: DiscoveryType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDeviceDiscoveriesResponse {
        let input = ListDeviceDiscoveriesRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            statusFilter: statusFilter, 
            typeFilter: typeFilter
        )
        return try await self.listDeviceDiscoveries(input, logger: logger)
    }

    /// Lists all devices discovered during a specific device discovery task.
    @Sendable
    @inlinable
    public func listDiscoveredDevices(_ input: ListDiscoveredDevicesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListDiscoveredDevicesResponse {
        try await self.client.execute(
            operation: "ListDiscoveredDevices", 
            path: "/device-discoveries/{Identifier}/devices", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all devices discovered during a specific device discovery task.
    ///
    /// Parameters:
    ///   - identifier: The identifier of the device discovery job to list discovered devices for.
    ///   - maxResults: The maximum number of discovered devices to return in a single response.
    ///   - nextToken: A token used for pagination of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDiscoveredDevices(
        identifier: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDiscoveredDevicesResponse {
        let input = ListDiscoveredDevicesRequest(
            identifier: identifier, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDiscoveredDevices(input, logger: logger)
    }

    /// List all event log configurations for an account.
    @Sendable
    @inlinable
    public func listEventLogConfigurations(_ input: ListEventLogConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListEventLogConfigurationsResponse {
        try await self.client.execute(
            operation: "ListEventLogConfigurations", 
            path: "/event-log-configurations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List all event log configurations for an account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - nextToken: A token that can be used to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listEventLogConfigurations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListEventLogConfigurationsResponse {
        let input = ListEventLogConfigurationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listEventLogConfigurations(input, logger: logger)
    }

    /// Lists all account associations for a specific managed thing.
    @Sendable
    @inlinable
    public func listManagedThingAccountAssociations(_ input: ListManagedThingAccountAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListManagedThingAccountAssociationsResponse {
        try await self.client.execute(
            operation: "ListManagedThingAccountAssociations", 
            path: "/managed-thing-associations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all account associations for a specific managed thing.
    ///
    /// Parameters:
    ///   - accountAssociationId: The identifier of the account association to filter results by. When specified, only associations with this account association ID will be returned.
    ///   - managedThingId: The identifier of the managed thing to list account associations for.
    ///   - maxResults: The maximum number of account associations to return in a single response.
    ///   - nextToken: A token used for pagination of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listManagedThingAccountAssociations(
        accountAssociationId: String? = nil,
        managedThingId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListManagedThingAccountAssociationsResponse {
        let input = ListManagedThingAccountAssociationsRequest(
            accountAssociationId: accountAssociationId, 
            managedThingId: managedThingId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listManagedThingAccountAssociations(input, logger: logger)
    }

    /// List schemas associated with a managed thing.
    @Sendable
    @inlinable
    public func listManagedThingSchemas(_ input: ListManagedThingSchemasRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListManagedThingSchemasResponse {
        try await self.client.execute(
            operation: "ListManagedThingSchemas", 
            path: "/managed-thing-schemas/{Identifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List schemas associated with a managed thing.
    ///
    /// Parameters:
    ///   - capabilityIdFilter: Filter on a capability id.
    ///   - endpointIdFilter: Filter on an endpoint id.
    ///   - identifier: The managed thing id.
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - nextToken: A token that can be used to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listManagedThingSchemas(
        capabilityIdFilter: String? = nil,
        endpointIdFilter: String? = nil,
        identifier: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListManagedThingSchemasResponse {
        let input = ListManagedThingSchemasRequest(
            capabilityIdFilter: capabilityIdFilter, 
            endpointIdFilter: endpointIdFilter, 
            identifier: identifier, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listManagedThingSchemas(input, logger: logger)
    }

    /// Listing all managed things with provision for filters.
    @Sendable
    @inlinable
    public func listManagedThings(_ input: ListManagedThingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListManagedThingsResponse {
        try await self.client.execute(
            operation: "ListManagedThings", 
            path: "/managed-things", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Listing all managed things with provision for filters.
    ///
    /// Parameters:
    ///   - connectorDestinationIdFilter: Filter managed things by the connector destination ID they are associated with.
    ///   - connectorDeviceIdFilter: Filter managed things by the connector device ID they are associated with. When specified, only managed things with this connector device ID will be returned.
    ///   - credentialLockerFilter: Filter on a credential locker for a managed thing.
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - nextToken: A token that can be used to retrieve the next set of results.
    ///   - ownerFilter: Filter on device owners when listing managed things.
    ///   - parentControllerIdentifierFilter: Filter on a parent controller id for a managed thing.
    ///   - provisioningStatusFilter: Filter on the status of the device.
    ///   - roleFilter: Filter on the type of device used. This will be the Amazon Web Services hub controller, cloud device, or IoT device.
    ///   - serialNumberFilter: Filter on the serial number of the device.
    ///   - logger: Logger use during operation
    @inlinable
    public func listManagedThings(
        connectorDestinationIdFilter: String? = nil,
        connectorDeviceIdFilter: String? = nil,
        credentialLockerFilter: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        ownerFilter: String? = nil,
        parentControllerIdentifierFilter: String? = nil,
        provisioningStatusFilter: ProvisioningStatus? = nil,
        roleFilter: Role? = nil,
        serialNumberFilter: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListManagedThingsResponse {
        let input = ListManagedThingsRequest(
            connectorDestinationIdFilter: connectorDestinationIdFilter, 
            connectorDeviceIdFilter: connectorDeviceIdFilter, 
            credentialLockerFilter: credentialLockerFilter, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            ownerFilter: ownerFilter, 
            parentControllerIdentifierFilter: parentControllerIdentifierFilter, 
            provisioningStatusFilter: provisioningStatusFilter, 
            roleFilter: roleFilter, 
            serialNumberFilter: serialNumberFilter
        )
        return try await self.listManagedThings(input, logger: logger)
    }

    ///  List all notification configurations.
    @Sendable
    @inlinable
    public func listNotificationConfigurations(_ input: ListNotificationConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListNotificationConfigurationsResponse {
        try await self.client.execute(
            operation: "ListNotificationConfigurations", 
            path: "/notification-configurations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  List all notification configurations.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - nextToken: A token that can be used to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listNotificationConfigurations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListNotificationConfigurationsResponse {
        let input = ListNotificationConfigurationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listNotificationConfigurations(input, logger: logger)
    }

    /// List all of the over-the-air (OTA) task configurations.
    @Sendable
    @inlinable
    public func listOtaTaskConfigurations(_ input: ListOtaTaskConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOtaTaskConfigurationsResponse {
        try await self.client.execute(
            operation: "ListOtaTaskConfigurations", 
            path: "/ota-task-configurations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List all of the over-the-air (OTA) task configurations.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - nextToken: A token that can be used to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOtaTaskConfigurations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOtaTaskConfigurationsResponse {
        let input = ListOtaTaskConfigurationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listOtaTaskConfigurations(input, logger: logger)
    }

    /// List all of the over-the-air (OTA) task executions.
    @Sendable
    @inlinable
    public func listOtaTaskExecutions(_ input: ListOtaTaskExecutionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOtaTaskExecutionsResponse {
        try await self.client.execute(
            operation: "ListOtaTaskExecutions", 
            path: "/ota-tasks/{Identifier}/devices", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List all of the over-the-air (OTA) task executions.
    ///
    /// Parameters:
    ///   - identifier: The over-the-air (OTA) task id.
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - nextToken: A token that can be used to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOtaTaskExecutions(
        identifier: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOtaTaskExecutionsResponse {
        let input = ListOtaTaskExecutionsRequest(
            identifier: identifier, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listOtaTaskExecutions(input, logger: logger)
    }

    /// List all of the over-the-air (OTA) tasks.
    @Sendable
    @inlinable
    public func listOtaTasks(_ input: ListOtaTasksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOtaTasksResponse {
        try await self.client.execute(
            operation: "ListOtaTasks", 
            path: "/ota-tasks", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List all of the over-the-air (OTA) tasks.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - nextToken: A token that can be used to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOtaTasks(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOtaTasksResponse {
        let input = ListOtaTasksRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listOtaTasks(input, logger: logger)
    }

    /// List the provisioning profiles within the Amazon Web Services account.
    @Sendable
    @inlinable
    public func listProvisioningProfiles(_ input: ListProvisioningProfilesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListProvisioningProfilesResponse {
        try await self.client.execute(
            operation: "ListProvisioningProfiles", 
            path: "/provisioning-profiles", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List the provisioning profiles within the Amazon Web Services account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - nextToken: A token that can be used to retrieve the next set of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listProvisioningProfiles(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListProvisioningProfilesResponse {
        let input = ListProvisioningProfilesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listProvisioningProfiles(input, logger: logger)
    }

    /// Lists schema versions with the provided information.
    @Sendable
    @inlinable
    public func listSchemaVersions(_ input: ListSchemaVersionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSchemaVersionsResponse {
        try await self.client.execute(
            operation: "ListSchemaVersions", 
            path: "/schema-versions/{Type}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists schema versions with the provided information.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - namespace: Filter on the name of the schema version.
    ///   - nextToken: A token that can be used to retrieve the next set of results.
    ///   - schemaId: Filter on the id of the schema version.
    ///   - semanticVersion: The schema version. If this is left blank, it defaults to the latest version.
    ///   - type: Filter on the type of schema version.
    ///   - visibility: The visibility of the schema version.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSchemaVersions(
        maxResults: Int? = nil,
        namespace: String? = nil,
        nextToken: String? = nil,
        schemaId: String? = nil,
        semanticVersion: String? = nil,
        type: SchemaVersionType,
        visibility: SchemaVersionVisibility? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSchemaVersionsResponse {
        let input = ListSchemaVersionsRequest(
            maxResults: maxResults, 
            namespace: namespace, 
            nextToken: nextToken, 
            schemaId: schemaId, 
            semanticVersion: semanticVersion, 
            type: type, 
            visibility: visibility
        )
        return try await self.listSchemaVersions(input, logger: logger)
    }

    /// List tags for the specified resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// List tags for the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The ARN of the resource for which to list tags.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Sets the default encryption configuration for the Amazon Web Services account. For more information, see Key management in the AWS IoT SiteWise User Guide.
    @Sendable
    @inlinable
    public func putDefaultEncryptionConfiguration(_ input: PutDefaultEncryptionConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutDefaultEncryptionConfigurationResponse {
        try await self.client.execute(
            operation: "PutDefaultEncryptionConfiguration", 
            path: "/configuration/account/encryption", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Sets the default encryption configuration for the Amazon Web Services account. For more information, see Key management in the AWS IoT SiteWise User Guide.
    ///
    /// Parameters:
    ///   - encryptionType: The type of encryption used for the encryption configuration.
    ///   - kmsKeyArn: The Key Amazon Resource Name (ARN) of the AWS KMS key used for KMS encryption if you use KMS_BASED_ENCRYPTION.
    ///   - logger: Logger use during operation
    @inlinable
    public func putDefaultEncryptionConfiguration(
        encryptionType: EncryptionType,
        kmsKeyArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutDefaultEncryptionConfigurationResponse {
        let input = PutDefaultEncryptionConfigurationRequest(
            encryptionType: encryptionType, 
            kmsKeyArn: kmsKeyArn
        )
        return try await self.putDefaultEncryptionConfiguration(input, logger: logger)
    }

    /// Update a hub configuration.
    @Sendable
    @inlinable
    public func putHubConfiguration(_ input: PutHubConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutHubConfigurationResponse {
        try await self.client.execute(
            operation: "PutHubConfiguration", 
            path: "/hub-configuration", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update a hub configuration.
    ///
    /// Parameters:
    ///   - hubTokenTimerExpirySettingInSeconds: A user-defined integer value that represents the hub token timer expiry setting in seconds.
    ///   - logger: Logger use during operation
    @inlinable
    public func putHubConfiguration(
        hubTokenTimerExpirySettingInSeconds: Int64,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutHubConfigurationResponse {
        let input = PutHubConfigurationRequest(
            hubTokenTimerExpirySettingInSeconds: hubTokenTimerExpirySettingInSeconds
        )
        return try await self.putHubConfiguration(input, logger: logger)
    }

    /// Set the runtime log configuration for a specific managed thing or for all managed things as a group.
    @Sendable
    @inlinable
    public func putRuntimeLogConfiguration(_ input: PutRuntimeLogConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "PutRuntimeLogConfiguration", 
            path: "/runtime-log-configurations/{ManagedThingId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Set the runtime log configuration for a specific managed thing or for all managed things as a group.
    ///
    /// Parameters:
    ///   - managedThingId: The id for a managed thing.
    ///   - runtimeLogConfigurations: The runtime log configuration for a managed thing.
    ///   - logger: Logger use during operation
    @inlinable
    public func putRuntimeLogConfiguration(
        managedThingId: String,
        runtimeLogConfigurations: RuntimeLogConfigurations,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = PutRuntimeLogConfigurationRequest(
            managedThingId: managedThingId, 
            runtimeLogConfigurations: runtimeLogConfigurations
        )
        return try await self.putRuntimeLogConfiguration(input, logger: logger)
    }

    /// Registers an account association with a managed thing, establishing a connection between a device and a third-party account.
    @Sendable
    @inlinable
    public func registerAccountAssociation(_ input: RegisterAccountAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RegisterAccountAssociationResponse {
        try await self.client.execute(
            operation: "RegisterAccountAssociation", 
            path: "/managed-thing-associations/register", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Registers an account association with a managed thing, establishing a connection between a device and a third-party account.
    ///
    /// Parameters:
    ///   - accountAssociationId: The identifier of the account association to register with the managed thing.
    ///   - deviceDiscoveryId: The identifier of the device discovery job associated with this registration.
    ///   - managedThingId: The identifier of the managed thing to register with the account association.
    ///   - logger: Logger use during operation
    @inlinable
    public func registerAccountAssociation(
        accountAssociationId: String,
        deviceDiscoveryId: String,
        managedThingId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RegisterAccountAssociationResponse {
        let input = RegisterAccountAssociationRequest(
            accountAssociationId: accountAssociationId, 
            deviceDiscoveryId: deviceDiscoveryId, 
            managedThingId: managedThingId
        )
        return try await self.registerAccountAssociation(input, logger: logger)
    }

    /// Customers can request IoT managed integrations to manage the server trust for them or bring their own external server trusts for the custom domain. Returns an IoT managed integrations endpoint.
    @Sendable
    @inlinable
    public func registerCustomEndpoint(_ input: RegisterCustomEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RegisterCustomEndpointResponse {
        try await self.client.execute(
            operation: "RegisterCustomEndpoint", 
            path: "/custom-endpoint", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Customers can request IoT managed integrations to manage the server trust for them or bring their own external server trusts for the custom domain. Returns an IoT managed integrations endpoint.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func registerCustomEndpoint(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RegisterCustomEndpointResponse {
        let input = RegisterCustomEndpointRequest(
        )
        return try await self.registerCustomEndpoint(input, logger: logger)
    }

    /// Reset a runtime log configuration for a specific managed thing or for all managed things as a group.
    @Sendable
    @inlinable
    public func resetRuntimeLogConfiguration(_ input: ResetRuntimeLogConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "ResetRuntimeLogConfiguration", 
            path: "/runtime-log-configurations/{ManagedThingId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Reset a runtime log configuration for a specific managed thing or for all managed things as a group.
    ///
    /// Parameters:
    ///   - managedThingId: The id of a managed thing.
    ///   - logger: Logger use during operation
    @inlinable
    public func resetRuntimeLogConfiguration(
        managedThingId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = ResetRuntimeLogConfigurationRequest(
            managedThingId: managedThingId
        )
        return try await self.resetRuntimeLogConfiguration(input, logger: logger)
    }

    /// Relays third-party device events for a connector such as a new device or a device state change event.
    @Sendable
    @inlinable
    public func sendConnectorEvent(_ input: SendConnectorEventRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendConnectorEventResponse {
        try await self.client.execute(
            operation: "SendConnectorEvent", 
            path: "/connector-event/{ConnectorId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Relays third-party device events for a connector such as a new device or a device state change event.
    ///
    /// Parameters:
    ///   - connectorDeviceId: The third-party device id as defined by the connector. This device id must not contain personal identifiable information (PII).  This parameter is used for cloud-to-cloud devices only.
    ///   - connectorId: The id of the connector between the third-party cloud provider and IoT managed integrations.
    ///   - deviceDiscoveryId: The id for the device discovery job.
    ///   - devices: The list of devices.
    ///   - matterEndpoint: The device endpoint.
    ///   - message: The device state change event payload. This parameter will include the following three fields:    uri: schema auc://&lt;PARTNER-DEVICE-ID&gt;/ResourcePath (The Resourcepath corresponds to an OCF resource.)    op: For device state changes, this field must populate as n+d.    cn: The content depends on the OCF resource referenced in ResourcePath.
    ///   - operation: The Open Connectivity Foundation (OCF) operation requested to be performed on the managed thing.  The field op can have a value of "I" or "U". The field "cn" will contain the capability types.
    ///   - operationVersion: The Open Connectivity Foundation (OCF) security specification version for the operation being requested on the managed thing. For more information, see OCF Security Specification.
    ///   - statusCode: The status code of the Open Connectivity Foundation (OCF) operation being performed on the managed thing.
    ///   - traceId: The trace request identifier used to correlate a command request and response. This is specified by the device owner, but will be generated by IoT managed integrations if not provided by the device owner.
    ///   - userId: The id of the third-party cloud provider.
    ///   - logger: Logger use during operation
    @inlinable
    public func sendConnectorEvent(
        connectorDeviceId: String? = nil,
        connectorId: String,
        deviceDiscoveryId: String? = nil,
        devices: [Device]? = nil,
        matterEndpoint: MatterEndpoint? = nil,
        message: String? = nil,
        operation: ConnectorEventOperation,
        operationVersion: String? = nil,
        statusCode: Int? = nil,
        traceId: String? = nil,
        userId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendConnectorEventResponse {
        let input = SendConnectorEventRequest(
            connectorDeviceId: connectorDeviceId, 
            connectorId: connectorId, 
            deviceDiscoveryId: deviceDiscoveryId, 
            devices: devices, 
            matterEndpoint: matterEndpoint, 
            message: message, 
            operation: operation, 
            operationVersion: operationVersion, 
            statusCode: statusCode, 
            traceId: traceId, 
            userId: userId
        )
        return try await self.sendConnectorEvent(input, logger: logger)
    }

    /// Send the command to the device represented by the managed thing.
    @Sendable
    @inlinable
    public func sendManagedThingCommand(_ input: SendManagedThingCommandRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SendManagedThingCommandResponse {
        try await self.client.execute(
            operation: "SendManagedThingCommand", 
            path: "/managed-things-command/{ManagedThingId}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Send the command to the device represented by the managed thing.
    ///
    /// Parameters:
    ///   - accountAssociationId: The identifier of the account association to use when sending a command to a managed thing.
    ///   - endpoints: The device endpoint.
    ///   - managedThingId: The id of the device.
    ///   - logger: Logger use during operation
    @inlinable
    public func sendManagedThingCommand(
        accountAssociationId: String? = nil,
        endpoints: [CommandEndpoint],
        managedThingId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SendManagedThingCommandResponse {
        let input = SendManagedThingCommandRequest(
            accountAssociationId: accountAssociationId, 
            endpoints: endpoints, 
            managedThingId: managedThingId
        )
        return try await self.sendManagedThingCommand(input, logger: logger)
    }

    /// Initiates a refresh of an existing account association to update its authorization and connection status.
    @Sendable
    @inlinable
    public func startAccountAssociationRefresh(_ input: StartAccountAssociationRefreshRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartAccountAssociationRefreshResponse {
        try await self.client.execute(
            operation: "StartAccountAssociationRefresh", 
            path: "/account-associations/{AccountAssociationId}/refresh", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Initiates a refresh of an existing account association to update its authorization and connection status.
    ///
    /// Parameters:
    ///   - accountAssociationId: The unique identifier of the account association to refresh.
    ///   - logger: Logger use during operation
    @inlinable
    public func startAccountAssociationRefresh(
        accountAssociationId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartAccountAssociationRefreshResponse {
        let input = StartAccountAssociationRefreshRequest(
            accountAssociationId: accountAssociationId
        )
        return try await self.startAccountAssociationRefresh(input, logger: logger)
    }

    ///  This API is used to start device discovery for hub-connected and third-party-connected devices. The authentication material (install code) is passed as a message to the controller telling it to start the discovery.
    @Sendable
    @inlinable
    public func startDeviceDiscovery(_ input: StartDeviceDiscoveryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> StartDeviceDiscoveryResponse {
        try await self.client.execute(
            operation: "StartDeviceDiscovery", 
            path: "/device-discoveries", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  This API is used to start device discovery for hub-connected and third-party-connected devices. The authentication material (install code) is passed as a message to the controller telling it to start the discovery.
    ///
    /// Parameters:
    ///   - accountAssociationId: The identifier of the cloud-to-cloud account association to use for discovery of third-party devices.
    ///   - authenticationMaterial: The authentication material required to start the local device discovery job request.
    ///   - authenticationMaterialType: The type of authentication material used for device discovery jobs.
    ///   - clientToken: An idempotency token. If you retry a request that completed successfully initially using the same client token and parameters, then the retry attempt will succeed without performing any further actions.
    ///   - controllerIdentifier: The id of the end-user's IoT hub.
    ///   - customProtocolDetail: Additional protocol-specific details required for device discovery, which vary based on the discovery type.  For a DiscoveryType of CUSTOM, the string-to-string map must have a key value of Name set to a non-empty-string.
    ///   - discoveryType: The discovery type supporting the type of device to be discovered in the device discovery task request.
    ///   - logger: Logger use during operation
    @inlinable
    public func startDeviceDiscovery(
        accountAssociationId: String? = nil,
        authenticationMaterial: String? = nil,
        authenticationMaterialType: DiscoveryAuthMaterialType? = nil,
        clientToken: String? = nil,
        controllerIdentifier: String? = nil,
        customProtocolDetail: [String: String]? = nil,
        discoveryType: DiscoveryType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartDeviceDiscoveryResponse {
        let input = StartDeviceDiscoveryRequest(
            accountAssociationId: accountAssociationId, 
            authenticationMaterial: authenticationMaterial, 
            authenticationMaterialType: authenticationMaterialType, 
            clientToken: clientToken, 
            controllerIdentifier: controllerIdentifier, 
            customProtocolDetail: customProtocolDetail, 
            discoveryType: discoveryType
        )
        return try await self.startDeviceDiscovery(input, logger: logger)
    }

    /// Add tags for the specified resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Add tags for the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The ARN of the resource to which to add tags.
    ///   - tags: A set of key/value pairs that are used to manage the resource
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Remove tags for the specified resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Remove tags for the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The ARN of the resource to which to add tags.
    ///   - tagKeys: A list of tag keys to remove from the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the properties of an existing account association.
    @Sendable
    @inlinable
    public func updateAccountAssociation(_ input: UpdateAccountAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateAccountAssociation", 
            path: "/account-associations/{AccountAssociationId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the properties of an existing account association.
    ///
    /// Parameters:
    ///   - accountAssociationId: The unique identifier of the account association to update.
    ///   - description: The new description to assign to the account association.
    ///   - name: The new name to assign to the account association.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAccountAssociation(
        accountAssociationId: String,
        description: String? = nil,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateAccountAssociationRequest(
            accountAssociationId: accountAssociationId, 
            description: description, 
            name: name
        )
        return try await self.updateAccountAssociation(input, logger: logger)
    }

    /// Update an existing cloud connector.
    @Sendable
    @inlinable
    public func updateCloudConnector(_ input: UpdateCloudConnectorRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateCloudConnector", 
            path: "/cloud-connectors/{Identifier}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update an existing cloud connector.
    ///
    /// Parameters:
    ///   - description: The new description to assign to the cloud connector.
    ///   - identifier: The unique identifier of the cloud connector to update.
    ///   - name: The new display name to assign to the cloud connector.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCloudConnector(
        description: String? = nil,
        identifier: String,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateCloudConnectorRequest(
            description: description, 
            identifier: identifier, 
            name: name
        )
        return try await self.updateCloudConnector(input, logger: logger)
    }

    /// Updates the properties of an existing connector destination.
    @Sendable
    @inlinable
    public func updateConnectorDestination(_ input: UpdateConnectorDestinationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateConnectorDestination", 
            path: "/connector-destinations/{Identifier}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the properties of an existing connector destination.
    ///
    /// Parameters:
    ///   - authConfig: The updated authentication configuration details for the connector destination.
    ///   - authType: The new authentication type to use for the connector destination.
    ///   - description: The new description to assign to the connector destination.
    ///   - identifier: The unique identifier of the connector destination to update.
    ///   - name: The new display name to assign to the connector destination.
    ///   - secretsManager: The updated AWS Secrets Manager configuration for the connector destination.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateConnectorDestination(
        authConfig: AuthConfigUpdate? = nil,
        authType: AuthType? = nil,
        description: String? = nil,
        identifier: String,
        name: String? = nil,
        secretsManager: SecretsManager? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateConnectorDestinationRequest(
            authConfig: authConfig, 
            authType: authType, 
            description: description, 
            identifier: identifier, 
            name: name, 
            secretsManager: secretsManager
        )
        return try await self.updateConnectorDestination(input, logger: logger)
    }

    ///  Update a destination specified by id.
    @Sendable
    @inlinable
    public func updateDestination(_ input: UpdateDestinationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateDestination", 
            path: "/destinations/{Name}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Update a destination specified by id.
    ///
    /// Parameters:
    ///   - deliveryDestinationArn: The Amazon Resource Name (ARN) of the customer-managed destination.
    ///   - deliveryDestinationType: The destination type for the customer-managed destination.
    ///   - description: The description of the customer-managed destination.
    ///   - name: The name of the customer-managed destination.
    ///   - roleArn: The Amazon Resource Name (ARN) of the delivery destination role.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDestination(
        deliveryDestinationArn: String? = nil,
        deliveryDestinationType: DeliveryDestinationType? = nil,
        description: String? = nil,
        name: String,
        roleArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateDestinationRequest(
            deliveryDestinationArn: deliveryDestinationArn, 
            deliveryDestinationType: deliveryDestinationType, 
            description: description, 
            name: name, 
            roleArn: roleArn
        )
        return try await self.updateDestination(input, logger: logger)
    }

    /// Update an event log configuration by log configuration ID.
    @Sendable
    @inlinable
    public func updateEventLogConfiguration(_ input: UpdateEventLogConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateEventLogConfiguration", 
            path: "/event-log-configurations/{Id}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update an event log configuration by log configuration ID.
    ///
    /// Parameters:
    ///   - eventLogLevel: The log level for the event in terms of severity.
    ///   - id: The log configuration id.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateEventLogConfiguration(
        eventLogLevel: LogLevel,
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateEventLogConfigurationRequest(
            eventLogLevel: eventLogLevel, 
            id: id
        )
        return try await self.updateEventLogConfiguration(input, logger: logger)
    }

    /// Update the attributes and capabilities associated with a managed thing.
    @Sendable
    @inlinable
    public func updateManagedThing(_ input: UpdateManagedThingRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateManagedThing", 
            path: "/managed-things/{Identifier}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update the attributes and capabilities associated with a managed thing.
    ///
    /// Parameters:
    ///   - brand: The brand of the device.
    ///   - capabilities: The capabilities of the device such as light bulb.
    ///   - capabilityReport: A report of the capabilities for the managed thing.
    ///   - capabilitySchemas: The updated capability schemas that define the functionality and features supported by the managed thing.
    ///   - classification: The classification of the managed thing such as light bulb or thermostat.
    ///   - credentialLockerId: The identifier of the credential for the managed thing.
    ///   - hubNetworkMode: The network mode for the hub-connected device.
    ///   - identifier: The id of the managed thing.
    ///   - metaData: The metadata for the managed thing.
    ///   - model: The model of the device.
    ///   - name: The name of the managed thing representing the physical device.
    ///   - owner: Owner of the device, usually an indication of whom the device belongs to. This value should not contain personal identifiable information.
    ///   - serialNumber: The serial number of the device.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateManagedThing(
        brand: String? = nil,
        capabilities: String? = nil,
        capabilityReport: CapabilityReport? = nil,
        capabilitySchemas: [CapabilitySchemaItem]? = nil,
        classification: String? = nil,
        credentialLockerId: String? = nil,
        hubNetworkMode: HubNetworkMode? = nil,
        identifier: String,
        metaData: [String: String]? = nil,
        model: String? = nil,
        name: String? = nil,
        owner: String? = nil,
        serialNumber: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateManagedThingRequest(
            brand: brand, 
            capabilities: capabilities, 
            capabilityReport: capabilityReport, 
            capabilitySchemas: capabilitySchemas, 
            classification: classification, 
            credentialLockerId: credentialLockerId, 
            hubNetworkMode: hubNetworkMode, 
            identifier: identifier, 
            metaData: metaData, 
            model: model, 
            name: name, 
            owner: owner, 
            serialNumber: serialNumber
        )
        return try await self.updateManagedThing(input, logger: logger)
    }

    ///  Update a notification configuration.
    @Sendable
    @inlinable
    public func updateNotificationConfiguration(_ input: UpdateNotificationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateNotificationConfiguration", 
            path: "/notification-configurations/{EventType}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Update a notification configuration.
    ///
    /// Parameters:
    ///   - destinationName: The name of the destination for the notification configuration.
    ///   - eventType: The type of event triggering a device notification to the customer-managed destination.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateNotificationConfiguration(
        destinationName: String,
        eventType: EventType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateNotificationConfigurationRequest(
            destinationName: destinationName, 
            eventType: eventType
        )
        return try await self.updateNotificationConfiguration(input, logger: logger)
    }

    /// Update an over-the-air (OTA) task.
    @Sendable
    @inlinable
    public func updateOtaTask(_ input: UpdateOtaTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UpdateOtaTask", 
            path: "/ota-tasks/{Identifier}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update an over-the-air (OTA) task.
    ///
    /// Parameters:
    ///   - description: The description of the over-the-air (OTA) task.
    ///   - identifier: The over-the-air (OTA) task id.
    ///   - taskConfigurationId: The identifier for the over-the-air (OTA) task configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateOtaTask(
        description: String? = nil,
        identifier: String,
        taskConfigurationId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UpdateOtaTaskRequest(
            description: description, 
            identifier: identifier, 
            taskConfigurationId: taskConfigurationId
        )
        return try await self.updateOtaTask(input, logger: logger)
    }
}

extension IoTManagedIntegrations {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: IoTManagedIntegrations, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension IoTManagedIntegrations {
    /// Return PaginatorSequence for operation ``listAccountAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAccountAssociationsPaginator(
        _ input: ListAccountAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAccountAssociationsRequest, ListAccountAssociationsResponse> {
        return .init(
            input: input,
            command: self.listAccountAssociations,
            inputKey: \ListAccountAssociationsRequest.nextToken,
            outputKey: \ListAccountAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAccountAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - connectorDestinationId: The identifier of the connector destination to filter account associations by.
    ///   - maxResults: The maximum number of account associations to return in a single response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAccountAssociationsPaginator(
        connectorDestinationId: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAccountAssociationsRequest, ListAccountAssociationsResponse> {
        let input = ListAccountAssociationsRequest(
            connectorDestinationId: connectorDestinationId, 
            maxResults: maxResults
        )
        return self.listAccountAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCloudConnectors(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCloudConnectorsPaginator(
        _ input: ListCloudConnectorsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCloudConnectorsRequest, ListCloudConnectorsResponse> {
        return .init(
            input: input,
            command: self.listCloudConnectors,
            inputKey: \ListCloudConnectorsRequest.nextToken,
            outputKey: \ListCloudConnectorsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCloudConnectors(_:logger:)``.
    ///
    /// - Parameters:
    ///   - lambdaArn: The Amazon Resource Name (ARN) of the Lambda function to filter cloud connectors by.
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - type: The type of cloud connectors to filter by when listing available connectors.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCloudConnectorsPaginator(
        lambdaArn: String? = nil,
        maxResults: Int? = nil,
        type: CloudConnectorType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCloudConnectorsRequest, ListCloudConnectorsResponse> {
        let input = ListCloudConnectorsRequest(
            lambdaArn: lambdaArn, 
            maxResults: maxResults, 
            type: type
        )
        return self.listCloudConnectorsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listConnectorDestinations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listConnectorDestinationsPaginator(
        _ input: ListConnectorDestinationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListConnectorDestinationsRequest, ListConnectorDestinationsResponse> {
        return .init(
            input: input,
            command: self.listConnectorDestinations,
            inputKey: \ListConnectorDestinationsRequest.nextToken,
            outputKey: \ListConnectorDestinationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listConnectorDestinations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - cloudConnectorId: The identifier of the cloud connector to filter connector destinations by.
    ///   - maxResults: The maximum number of connector destinations to return in a single response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listConnectorDestinationsPaginator(
        cloudConnectorId: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListConnectorDestinationsRequest, ListConnectorDestinationsResponse> {
        let input = ListConnectorDestinationsRequest(
            cloudConnectorId: cloudConnectorId, 
            maxResults: maxResults
        )
        return self.listConnectorDestinationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCredentialLockers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCredentialLockersPaginator(
        _ input: ListCredentialLockersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCredentialLockersRequest, ListCredentialLockersResponse> {
        return .init(
            input: input,
            command: self.listCredentialLockers,
            inputKey: \ListCredentialLockersRequest.nextToken,
            outputKey: \ListCredentialLockersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCredentialLockers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCredentialLockersPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCredentialLockersRequest, ListCredentialLockersResponse> {
        let input = ListCredentialLockersRequest(
            maxResults: maxResults
        )
        return self.listCredentialLockersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDestinations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDestinationsPaginator(
        _ input: ListDestinationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDestinationsRequest, ListDestinationsResponse> {
        return .init(
            input: input,
            command: self.listDestinations,
            inputKey: \ListDestinationsRequest.nextToken,
            outputKey: \ListDestinationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDestinations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDestinationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDestinationsRequest, ListDestinationsResponse> {
        let input = ListDestinationsRequest(
            maxResults: maxResults
        )
        return self.listDestinationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDeviceDiscoveries(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDeviceDiscoveriesPaginator(
        _ input: ListDeviceDiscoveriesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDeviceDiscoveriesRequest, ListDeviceDiscoveriesResponse> {
        return .init(
            input: input,
            command: self.listDeviceDiscoveries,
            inputKey: \ListDeviceDiscoveriesRequest.nextToken,
            outputKey: \ListDeviceDiscoveriesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDeviceDiscoveries(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of device discovery jobs to return in a single response.
    ///   - statusFilter: The status to filter device discovery jobs by.
    ///   - typeFilter: The discovery type to filter device discovery jobs by.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDeviceDiscoveriesPaginator(
        maxResults: Int? = nil,
        statusFilter: DeviceDiscoveryStatus? = nil,
        typeFilter: DiscoveryType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDeviceDiscoveriesRequest, ListDeviceDiscoveriesResponse> {
        let input = ListDeviceDiscoveriesRequest(
            maxResults: maxResults, 
            statusFilter: statusFilter, 
            typeFilter: typeFilter
        )
        return self.listDeviceDiscoveriesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listDiscoveredDevices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listDiscoveredDevicesPaginator(
        _ input: ListDiscoveredDevicesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListDiscoveredDevicesRequest, ListDiscoveredDevicesResponse> {
        return .init(
            input: input,
            command: self.listDiscoveredDevices,
            inputKey: \ListDiscoveredDevicesRequest.nextToken,
            outputKey: \ListDiscoveredDevicesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listDiscoveredDevices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - identifier: The identifier of the device discovery job to list discovered devices for.
    ///   - maxResults: The maximum number of discovered devices to return in a single response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listDiscoveredDevicesPaginator(
        identifier: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListDiscoveredDevicesRequest, ListDiscoveredDevicesResponse> {
        let input = ListDiscoveredDevicesRequest(
            identifier: identifier, 
            maxResults: maxResults
        )
        return self.listDiscoveredDevicesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listEventLogConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listEventLogConfigurationsPaginator(
        _ input: ListEventLogConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListEventLogConfigurationsRequest, ListEventLogConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listEventLogConfigurations,
            inputKey: \ListEventLogConfigurationsRequest.nextToken,
            outputKey: \ListEventLogConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listEventLogConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - logger: Logger used for logging
    @inlinable
    public func listEventLogConfigurationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListEventLogConfigurationsRequest, ListEventLogConfigurationsResponse> {
        let input = ListEventLogConfigurationsRequest(
            maxResults: maxResults
        )
        return self.listEventLogConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listManagedThingAccountAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedThingAccountAssociationsPaginator(
        _ input: ListManagedThingAccountAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListManagedThingAccountAssociationsRequest, ListManagedThingAccountAssociationsResponse> {
        return .init(
            input: input,
            command: self.listManagedThingAccountAssociations,
            inputKey: \ListManagedThingAccountAssociationsRequest.nextToken,
            outputKey: \ListManagedThingAccountAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listManagedThingAccountAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountAssociationId: The identifier of the account association to filter results by. When specified, only associations with this account association ID will be returned.
    ///   - managedThingId: The identifier of the managed thing to list account associations for.
    ///   - maxResults: The maximum number of account associations to return in a single response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedThingAccountAssociationsPaginator(
        accountAssociationId: String? = nil,
        managedThingId: String? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListManagedThingAccountAssociationsRequest, ListManagedThingAccountAssociationsResponse> {
        let input = ListManagedThingAccountAssociationsRequest(
            accountAssociationId: accountAssociationId, 
            managedThingId: managedThingId, 
            maxResults: maxResults
        )
        return self.listManagedThingAccountAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listManagedThingSchemas(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedThingSchemasPaginator(
        _ input: ListManagedThingSchemasRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListManagedThingSchemasRequest, ListManagedThingSchemasResponse> {
        return .init(
            input: input,
            command: self.listManagedThingSchemas,
            inputKey: \ListManagedThingSchemasRequest.nextToken,
            outputKey: \ListManagedThingSchemasResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listManagedThingSchemas(_:logger:)``.
    ///
    /// - Parameters:
    ///   - capabilityIdFilter: Filter on a capability id.
    ///   - endpointIdFilter: Filter on an endpoint id.
    ///   - identifier: The managed thing id.
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedThingSchemasPaginator(
        capabilityIdFilter: String? = nil,
        endpointIdFilter: String? = nil,
        identifier: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListManagedThingSchemasRequest, ListManagedThingSchemasResponse> {
        let input = ListManagedThingSchemasRequest(
            capabilityIdFilter: capabilityIdFilter, 
            endpointIdFilter: endpointIdFilter, 
            identifier: identifier, 
            maxResults: maxResults
        )
        return self.listManagedThingSchemasPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listManagedThings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedThingsPaginator(
        _ input: ListManagedThingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListManagedThingsRequest, ListManagedThingsResponse> {
        return .init(
            input: input,
            command: self.listManagedThings,
            inputKey: \ListManagedThingsRequest.nextToken,
            outputKey: \ListManagedThingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listManagedThings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - connectorDestinationIdFilter: Filter managed things by the connector destination ID they are associated with.
    ///   - connectorDeviceIdFilter: Filter managed things by the connector device ID they are associated with. When specified, only managed things with this connector device ID will be returned.
    ///   - credentialLockerFilter: Filter on a credential locker for a managed thing.
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - ownerFilter: Filter on device owners when listing managed things.
    ///   - parentControllerIdentifierFilter: Filter on a parent controller id for a managed thing.
    ///   - provisioningStatusFilter: Filter on the status of the device.
    ///   - roleFilter: Filter on the type of device used. This will be the Amazon Web Services hub controller, cloud device, or IoT device.
    ///   - serialNumberFilter: Filter on the serial number of the device.
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedThingsPaginator(
        connectorDestinationIdFilter: String? = nil,
        connectorDeviceIdFilter: String? = nil,
        credentialLockerFilter: String? = nil,
        maxResults: Int? = nil,
        ownerFilter: String? = nil,
        parentControllerIdentifierFilter: String? = nil,
        provisioningStatusFilter: ProvisioningStatus? = nil,
        roleFilter: Role? = nil,
        serialNumberFilter: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListManagedThingsRequest, ListManagedThingsResponse> {
        let input = ListManagedThingsRequest(
            connectorDestinationIdFilter: connectorDestinationIdFilter, 
            connectorDeviceIdFilter: connectorDeviceIdFilter, 
            credentialLockerFilter: credentialLockerFilter, 
            maxResults: maxResults, 
            ownerFilter: ownerFilter, 
            parentControllerIdentifierFilter: parentControllerIdentifierFilter, 
            provisioningStatusFilter: provisioningStatusFilter, 
            roleFilter: roleFilter, 
            serialNumberFilter: serialNumberFilter
        )
        return self.listManagedThingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listNotificationConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listNotificationConfigurationsPaginator(
        _ input: ListNotificationConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListNotificationConfigurationsRequest, ListNotificationConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listNotificationConfigurations,
            inputKey: \ListNotificationConfigurationsRequest.nextToken,
            outputKey: \ListNotificationConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listNotificationConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - logger: Logger used for logging
    @inlinable
    public func listNotificationConfigurationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListNotificationConfigurationsRequest, ListNotificationConfigurationsResponse> {
        let input = ListNotificationConfigurationsRequest(
            maxResults: maxResults
        )
        return self.listNotificationConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOtaTaskConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOtaTaskConfigurationsPaginator(
        _ input: ListOtaTaskConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOtaTaskConfigurationsRequest, ListOtaTaskConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listOtaTaskConfigurations,
            inputKey: \ListOtaTaskConfigurationsRequest.nextToken,
            outputKey: \ListOtaTaskConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOtaTaskConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - logger: Logger used for logging
    @inlinable
    public func listOtaTaskConfigurationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOtaTaskConfigurationsRequest, ListOtaTaskConfigurationsResponse> {
        let input = ListOtaTaskConfigurationsRequest(
            maxResults: maxResults
        )
        return self.listOtaTaskConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOtaTaskExecutions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOtaTaskExecutionsPaginator(
        _ input: ListOtaTaskExecutionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOtaTaskExecutionsRequest, ListOtaTaskExecutionsResponse> {
        return .init(
            input: input,
            command: self.listOtaTaskExecutions,
            inputKey: \ListOtaTaskExecutionsRequest.nextToken,
            outputKey: \ListOtaTaskExecutionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOtaTaskExecutions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - identifier: The over-the-air (OTA) task id.
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - logger: Logger used for logging
    @inlinable
    public func listOtaTaskExecutionsPaginator(
        identifier: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOtaTaskExecutionsRequest, ListOtaTaskExecutionsResponse> {
        let input = ListOtaTaskExecutionsRequest(
            identifier: identifier, 
            maxResults: maxResults
        )
        return self.listOtaTaskExecutionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOtaTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOtaTasksPaginator(
        _ input: ListOtaTasksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOtaTasksRequest, ListOtaTasksResponse> {
        return .init(
            input: input,
            command: self.listOtaTasks,
            inputKey: \ListOtaTasksRequest.nextToken,
            outputKey: \ListOtaTasksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOtaTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - logger: Logger used for logging
    @inlinable
    public func listOtaTasksPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOtaTasksRequest, ListOtaTasksResponse> {
        let input = ListOtaTasksRequest(
            maxResults: maxResults
        )
        return self.listOtaTasksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listProvisioningProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listProvisioningProfilesPaginator(
        _ input: ListProvisioningProfilesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListProvisioningProfilesRequest, ListProvisioningProfilesResponse> {
        return .init(
            input: input,
            command: self.listProvisioningProfiles,
            inputKey: \ListProvisioningProfilesRequest.nextToken,
            outputKey: \ListProvisioningProfilesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listProvisioningProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - logger: Logger used for logging
    @inlinable
    public func listProvisioningProfilesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListProvisioningProfilesRequest, ListProvisioningProfilesResponse> {
        let input = ListProvisioningProfilesRequest(
            maxResults: maxResults
        )
        return self.listProvisioningProfilesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSchemaVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSchemaVersionsPaginator(
        _ input: ListSchemaVersionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSchemaVersionsRequest, ListSchemaVersionsResponse> {
        return .init(
            input: input,
            command: self.listSchemaVersions,
            inputKey: \ListSchemaVersionsRequest.nextToken,
            outputKey: \ListSchemaVersionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSchemaVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return at one time.
    ///   - namespace: Filter on the name of the schema version.
    ///   - schemaId: Filter on the id of the schema version.
    ///   - semanticVersion: The schema version. If this is left blank, it defaults to the latest version.
    ///   - type: Filter on the type of schema version.
    ///   - visibility: The visibility of the schema version.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSchemaVersionsPaginator(
        maxResults: Int? = nil,
        namespace: String? = nil,
        schemaId: String? = nil,
        semanticVersion: String? = nil,
        type: SchemaVersionType,
        visibility: SchemaVersionVisibility? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSchemaVersionsRequest, ListSchemaVersionsResponse> {
        let input = ListSchemaVersionsRequest(
            maxResults: maxResults, 
            namespace: namespace, 
            schemaId: schemaId, 
            semanticVersion: semanticVersion, 
            type: type, 
            visibility: visibility
        )
        return self.listSchemaVersionsPaginator(input, logger: logger)
    }
}

extension IoTManagedIntegrations.ListAccountAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListAccountAssociationsRequest {
        return .init(
            connectorDestinationId: self.connectorDestinationId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListCloudConnectorsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListCloudConnectorsRequest {
        return .init(
            lambdaArn: self.lambdaArn,
            maxResults: self.maxResults,
            nextToken: token,
            type: self.type
        )
    }
}

extension IoTManagedIntegrations.ListConnectorDestinationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListConnectorDestinationsRequest {
        return .init(
            cloudConnectorId: self.cloudConnectorId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListCredentialLockersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListCredentialLockersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListDestinationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListDestinationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListDeviceDiscoveriesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListDeviceDiscoveriesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            statusFilter: self.statusFilter,
            typeFilter: self.typeFilter
        )
    }
}

extension IoTManagedIntegrations.ListDiscoveredDevicesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListDiscoveredDevicesRequest {
        return .init(
            identifier: self.identifier,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListEventLogConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListEventLogConfigurationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListManagedThingAccountAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListManagedThingAccountAssociationsRequest {
        return .init(
            accountAssociationId: self.accountAssociationId,
            managedThingId: self.managedThingId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListManagedThingSchemasRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListManagedThingSchemasRequest {
        return .init(
            capabilityIdFilter: self.capabilityIdFilter,
            endpointIdFilter: self.endpointIdFilter,
            identifier: self.identifier,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListManagedThingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListManagedThingsRequest {
        return .init(
            connectorDestinationIdFilter: self.connectorDestinationIdFilter,
            connectorDeviceIdFilter: self.connectorDeviceIdFilter,
            credentialLockerFilter: self.credentialLockerFilter,
            maxResults: self.maxResults,
            nextToken: token,
            ownerFilter: self.ownerFilter,
            parentControllerIdentifierFilter: self.parentControllerIdentifierFilter,
            provisioningStatusFilter: self.provisioningStatusFilter,
            roleFilter: self.roleFilter,
            serialNumberFilter: self.serialNumberFilter
        )
    }
}

extension IoTManagedIntegrations.ListNotificationConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListNotificationConfigurationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListOtaTaskConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListOtaTaskConfigurationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListOtaTaskExecutionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListOtaTaskExecutionsRequest {
        return .init(
            identifier: self.identifier,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListOtaTasksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListOtaTasksRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListProvisioningProfilesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListProvisioningProfilesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTManagedIntegrations.ListSchemaVersionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTManagedIntegrations.ListSchemaVersionsRequest {
        return .init(
            maxResults: self.maxResults,
            namespace: self.namespace,
            nextToken: token,
            schemaId: self.schemaId,
            semanticVersion: self.semanticVersion,
            type: self.type,
            visibility: self.visibility
        )
    }
}
